A Comparison of High-Level Approaches for Speeding Up Pathfinding

Most games being shipped today use some form of high-level abstraction such as a navmesh or waypoint graph for path planning. These structures can generally be represented in a form which is compact enough to meet the tight memory constraints in a game. But, when such a graph grows too large, finding paths can still be a complex task. This challenge was faced in Dragon Age: Origins and solved by adding an additional level of abstraction. In the last few years a variety of novel approaches have been developed for finding optimal paths through graphs with specific design applications for road networks. Currently these techniques cannot be feasibly applied to the lowest detail of movement possible in a game map, but can be applied to the high-level abstractions which are commonly found in games. In this paper we describe the pathfinding challenge faced before shipping the title Dragon Age: Origins and perform a postmortem analysis on the extended abstraction that was used in comparison to building more advanced heuristics or the use of contraction hierarchies. We show that contraction hierarchies and abstractions have similar overhead and performance and are both useful approaches for high-level planning in games. Introduction and Background The problem of finding paths in games is, on one level, well understood. In particular, while players in the game may traverse terrain with a fine-grained or even real-value representation, planning for movement occurs at a higher level of abstraction, generally represented by a graph. Such representations include navmeshes (Tozour 2002) or waypoint graphs (Lidén and Valve-Software 2002), but have also been described algorithmically, such as HPA* (Botea, Müller, and Schaeffer 2004). These representations may not necessarily solve underlying issues such as turning constraints (Pinter 2001; Sturtevant 2009), an issue we will not address here. These representations work well, but there are two possible shortcomings. First, they can either become so large that pathfinding within the abstract representation may still take longer than per-frame constraints. Second, if the abstract representation is too coarse, it may result in poor pathfinding behavior, as low-level obstacles may not be adequately represented in the abstraction. These two issues are linked, Copyright c © 2010, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. as creating a finer grained abstraction will result in a larger abstract graph. This issue was faced in the pathfinding system for the game Dragon Age: Origins (DAO) and was solved by adding a second level of abstraction on top of the existing abstraction previously described (Sturtevant 2007). But, no scientific analysis was performed to measure the effect of this approach, or to compare it with other possible approaches. The goal of this paper is to do both. In addition to analyzing the parameters that could have been used to tune the second level of abstraction, we look at alternate approaches to address this problem, a special abstraction called a contraction hierarchy, and better heuristics. In the last few years a variety of novel approaches have been designed for finding optimal paths through graphs with specific applications to road networks; see (Delling et al. 2009) for an overview. Currently these techniques cannot be feasibly applied to the lowest detail of movement possible in a game map, but can be applied to the high-level abstractions which are commonly found in games. These approaches include contraction hierarchies and ALT (A*, landmarks and triangle inequality) (Goldberg and Harrelson 2005), also called differential heuristics (Sturtevant et al. 2009). Our contributions are as follows. We publish for the first time the two-level approach used for pathfinding in Dragon Age: Origins and describe in detail why this approach was necessary. We adapt approaches from road networks to game constraints, and provide important comparisons for practically applying these approaches, showing the strength and weakness of each. We show that abstraction and contraction hierarchies can both be implemented efficiently and have similar performance, however the cases that are hard for each approach differ considerably. The heuristic approach we compare has reasonable performance, however the memory overhead and lack of incremental computation make it less desirable in practice.